home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / msn / MsnHttpSocket.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  10KB  |  295 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import threading
  5. import traceback
  6. import collections
  7. import time
  8. import logging
  9. import httplib
  10. import pprint
  11. import threading
  12. import util
  13. import util.allow_once as once
  14. import util.httplib2 as httplib2
  15. import common
  16. import common.asynchttp as asynchttp
  17. log = logging.getLogger('msnhttp')
  18. import msn
  19. MIMEParse = msn.util.mime_to_dict
  20.  
  21. class MsnHttpSocket(msn.MSNSocketBase):
  22.     POLLINTERVAL = 3
  23.     proto = 'http'
  24.     gateway_ip = 'gateway.messenger.hotmail.com'
  25.     gateway_path = '/gateway/gateway.dll'
  26.     gateway_port = 80
  27.     
  28.     def get_local_sockname(self):
  29.         return ('localhost', 0)
  30.  
  31.     
  32.     def endpoint(self):
  33.         if self.gateway_port != httplib.HTTP_PORT:
  34.             s = '%s://%s:%s%s' % (self.proto, self.gateway_ip, self.gateway_port, self.gateway_path)
  35.         else:
  36.             s = '%s://%s%s' % (self.proto, self.gateway_ip, self.gateway_path)
  37.         return s
  38.  
  39.     endpoint = property(endpoint)
  40.     
  41.     def __init__(self, *a, **k):
  42.         self._session_id = None
  43.         msn.MSNSocketBase.__init__(self, *a, **k)
  44.         self._q = []
  45.         self._waiting = False
  46.         self._poller = util.RepeatTimer(self.POLLINTERVAL, self._poll)
  47.         self._poller._verbose = False
  48.         self._closed = False
  49.         self._paused = False
  50.  
  51.     
  52.     def connect(self, type_host):
  53.         (type, host) = self._parse_addr(type_host)
  54.         self.typehost = type_host
  55.         self.type = type
  56.         self.host = self._server = host
  57.         self.on_connect()
  58.  
  59.     _connect = connect
  60.     
  61.     def _parse_addr(self, type_addr):
  62.         
  63.         try:
  64.             (type, addr) = type_addr
  65.         except (ValueError, TypeError):
  66.             raise TypeError("%r.connect argument must be <type 'tuple'> (type, addr) not %r (%r)", type(self).__name__, type(host_port), host_port)
  67.  
  68.         bad_addr = False
  69.         port = None
  70.         if len(addr) == 1:
  71.             host = addr[0]
  72.             port = 80
  73.         elif isinstance(addr, basestring):
  74.             (host, port) = util.srv_str_to_tuple(addr, 80)
  75.         elif len(addr) == 2:
  76.             (host, port) = addr
  77.         else:
  78.             bad_addr = True
  79.         
  80.         try:
  81.             port = int(port)
  82.         except ValueError:
  83.             bad_addr = True
  84.  
  85.         if bad_addr:
  86.             raise TypeError('%r.connect argument\'s second element must be either string ("srv" or "srv:port") or tuple (("srv", port) or ("srv",)).Got %r instead' % addr)
  87.         
  88.         return (type, host)
  89.  
  90.     
  91.     def connect_args_for(self, type, addr):
  92.         return ((type.upper(), addr),)
  93.  
  94.     
  95.     def _poll(self):
  96.         if not self._waiting:
  97.             self.send(None)
  98.         
  99.  
  100.     
  101.     def pause(self):
  102.         self._paused = True
  103.  
  104.     
  105.     def unpause(self):
  106.         self._paused = False
  107.         common.netcall(self.process)
  108.  
  109.     
  110.     def send(self, msgobj, trid = sentinel, callback = None, **kw):
  111.         self._q.append((msgobj, trid, callback, kw))
  112.         if not self._paused:
  113.             common.netcall(self.process)
  114.         
  115.  
  116.     send = util.callsback(send)
  117.     
  118.     def process(self):
  119.         if not (self._q) or self._waiting:
  120.             return None
  121.         
  122.         self._waiting = True
  123.         data = []
  124.         sending = []
  125.         queue = self._q[:]
  126.         self._q[:] = []
  127.         while queue:
  128.             (msgobj, trid, callback, kw) = queue.pop(0)
  129.             if msgobj is not None:
  130.                 self.set_trid(msgobj, trid)
  131.                 self.set_callbacks(msgobj, callback)
  132.                 data.append(str(msgobj))
  133.             
  134.             sending.append(callback)
  135.         if self._session_id is None:
  136.             url_kws = dict(Action = 'open', Server = self.type, IP = self.host)
  137.         elif len(data) == 0:
  138.             url_kws = dict(Action = 'poll', SessionID = self._session_id)
  139.         else:
  140.             url_kws = dict(SessionID = self._session_id)
  141.         data = ''.join(data)
  142.         req = self.make_request(url_kws, data = data)
  143.         
  144.         def _transport_error(_req = None, _resp = (None, None, None)):
  145.             log.error('Transport error in MsnHttpSocket: req = %r, resp = %r', _req, _resp)
  146.             if isinstance(_req, Exception):
  147.                 e = _req
  148.             elif isinstance(_resp, Exception):
  149.                 e = _resp
  150.             else:
  151.                 e = _resp
  152.             for cb in sending:
  153.                 cb_error = getattr(callback, 'error', None)
  154.                 if cb_error is not None:
  155.                     cb_error(self, e)
  156.                     continue
  157.             
  158.             
  159.             try:
  160.                 del self.gateway_ip
  161.             except AttributeError:
  162.                 pass
  163.  
  164.             self._on_send_error(e)
  165.  
  166.         asynchttp.httpopen(req, success = self._on_response, error = _transport_error)
  167.  
  168.     
  169.     def fix_session_id(self, sess):
  170.         return sess
  171.  
  172.     
  173.     def _on_response(self, request, response):
  174.         if request.get_data():
  175.             log.debug_s('OUT : %r', request.get_data())
  176.         
  177.         if self._session_id is None:
  178.             self._poller.start()
  179.         
  180.         session_info = MIMEParse(response['x-msn-messenger'])
  181.         self.gateway_ip = session_info.get('GW-IP', self.gateway_ip)
  182.         self._session_id = self.fix_session_id(session_info.get('SessionID', None))
  183.         close = session_info.get('Session', '').lower() == 'close'
  184.         if self._session_id is None and not close:
  185.             raise Exception("Didn't get a session ID!")
  186.         
  187.         self._waiting = False
  188.         if not close:
  189.             common.netcall(self.process)
  190.         
  191.         if close:
  192.             self._session_id = None
  193.         
  194.         data = response.body
  195.         self._process_data(data)
  196.         if close:
  197.             self.on_close()
  198.         
  199.  
  200.     
  201.     def _process_data(self, data):
  202.         line = data.readline()
  203.         while line:
  204.             payload = False
  205.             line.rstrip('\r\n')
  206.             dlist = line.split()
  207.             cmd = dlist[0]
  208.             if cmd in self.payload_commands:
  209.                 payload = True
  210.                 
  211.                 try:
  212.                     sz = int(dlist[-1])
  213.                 except ValueError:
  214.                     sz = 0
  215.  
  216.                 line += data.read(sz)
  217.             
  218.             
  219.             try:
  220.                 msg = msn.Message.from_net(line, payload)
  221.                 self.on_message(msg)
  222.             except Exception:
  223.                 e = None
  224.                 log.error('Error handling %r. e = %r', line, e)
  225.                 traceback.print_exc()
  226.  
  227.             line = data.readline()
  228.  
  229.     
  230.     def _on_send_error(self, e):
  231.         log.error('Something bad happened in MsnHttpSocket: %r', e)
  232.         self.on_conn_error(e)
  233.  
  234.     
  235.     def make_request(self, url_kws, data = None):
  236.         url = util.UrlQuery(self.endpoint, url_kws)
  237.         headers = {
  238.             'Accept': '*/*',
  239.             'Content-Type': 'text/xml; charset=utf-8',
  240.             'User-Agent': 'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.0; SIMBAR={0B74DA00-76D2-11DD-9ABA-0016CFF93348}; SLCC1; .NET CLR 2.0.50727; Media Center PC 5.0; .NET CLR 3.0.04506; .NET CLR 3.5.21022; .NET CLR 1.1.4322; Windows Live Messenger BETA 9.0.1407)',
  241.             'Cache-Control': 'no-cache',
  242.             'Accept-Language': 'en-us' }
  243.         req = asynchttp.HTTPRequest.make_request(url, data = data, headers = headers, method = 'POST')
  244.         return req
  245.  
  246.     
  247.     def close(self):
  248.         log.info('Closing %r', self)
  249.         del self._q[:]
  250.         if self._session_id is None:
  251.             self.on_close()
  252.         else:
  253.             self.send(msn.Message('OUT'))
  254.  
  255.     close = once.allow_once(close)
  256.     
  257.     def on_close(self):
  258.         log.info('on_close: %r', self)
  259.         self._closed = True
  260.         self._poller.stop()
  261.         self._on_response = Null
  262.         self._on_send_error = Null
  263.         self._session_id = None
  264.         self.gateway_ip = type(self).gateway_ip
  265.         del self._q[:]
  266.         self.pause()
  267.         msn.MSNSocketBase.on_close(self)
  268.  
  269.     _disconnect = close_when_done = close
  270.     
  271.     def __repr__(self):
  272.         return '<%s session_id=%r gateway_ip=%r>' % (type(self).__name__, self._session_id, self.gateway_ip)
  273.  
  274.  
  275.  
  276. def main():
  277.     scktype = MsnHttpSocket
  278.     sck = scktype()
  279.     args = sck.connect_args_for('NS', ('messenger.hotmail.com', 1863))
  280.     print args
  281.     sck.connect(*args)
  282.     sck.send(msn.Message('VER', 'MSNP8', 'CVR0'), trid = True)
  283.     app.toggle_crust()
  284.     app.MainLoop()
  285.  
  286. if __name__ == '__main__':
  287.     import digsbysite
  288.     import netextensions
  289.     from tests.testapp import testapp
  290.     logging.getLogger('events').setLevel(1)
  291.     app = testapp('.')
  292.     util.ThreadPool(5)
  293.     main()
  294.  
  295.